Hm, this is kind of a pre-existing problem, I can reproduce this on older versions with e.g. a deferral (or otherwise force re-visiting the function). But now the issue is more prominent, because with two-phase checking every function is in some sense deferred.

Patching the defn.type in-place is a sketchy thing (and also all the code around awaitable generators is sketchy, but I knew about this when I started the whole two-phase checking thing).

After some thinking, we probably shouldn't do the wrapping at all for dynamic functions for consistency with regular async def:

async def f(): ...
reveal_type(f)  # "def () -> Any", not "def () -> Coroutine[Any, Any, Any]"

Or vice-versa, we should wrap both. So what would it be? @JukkaL

(to be clear both ways have relatively simple fixes)

Let's try wrapping both!

Let's try wrapping both!

OK, let's see how it works. Btw there is another quirk that needed fixing, the

Use "-> None" if function does not return a value

note is added based on some random heuristics. I made some changes to preserve the current behavior (just to minimize number of ~unrelated changes in this PR)

According to mypy_primer, this change doesn't affect type check results on a corpus of open source code. ✅

Let's try wrapping both!

OK, let's see how it works

It didn't really work, whatever direction I go, a whole can of worms opens. So let's just fix the regression. The PR as it is now should be strictly better than both 2.0 (no crash) and 1.20 (dynamic functions don't stop being such when deferred).

I can confirm this fixes the issue in our code base. Thanks for picking this up!